.TH std::strong_order 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::strong_order \- std::strong_order

.SH Synopsis
   Defined in header <compare>
   inline namespace /* unspecified */ {

       inline constexpr /* unspecified */ strong_order = /* unspecified   \fI(since C++20)\fP
   */;

   }
   Call signature
   template< class T, class U >

       requires /* see below */

   constexpr std::strong_ordering strong_order( T&& t, U&& u )
   noexcept(/* see below */);

   Compares two values using 3-way comparison and produces a result of type
   std::strong_ordering.

   Let t and u be expressions and T and U denote decltype((t)) and decltype((u))
   respectively, std::strong_order(t, u) is expression-equivalent to:

     * If std::is_same_v<std::decay_t<T>, std::decay_t<U>> is true:
          * std::strong_ordering(strong_order(t, u)), if it is a well-formed expression
            with overload resolution performed in a context that does not include a
            declaration of std::strong_order,
          * otherwise, if T is a floating-point type:
               * if std::numeric_limits<T>::is_iec559 is true, performs the
                 ISO/IEC/IEEE 60559 totalOrder comparison of floating-point values and
                 returns that result as a value of type std::strong_ordering (note:
                 this comparison can distinguish between the positive and negative zero
                 and between the NaNs with different representations),
               * otherwise, yields a value of type std::strong_ordering that is
                 consistent with the ordering observed by T's comparison operators,
          * otherwise, std::strong_ordering(std::compare_three_way()(t, u)) if it is
            well-formed.
     * In all other cases, the expression is ill-formed, which can result in
       substitution failure when it appears in the immediate context of a template
       instantiation.

.SH Example

    This section is incomplete
    Reason: no example

.SH See also

   strong_ordering               the result type of 3-way comparison that supports all
   (C++20)                       6 operators and is substitutable
                                 \fI(class)\fP
   weak_order                    performs 3-way comparison and produces a result of
   (C++20)                       type std::weak_ordering
                                 (customization point object)
   partial_order                 performs 3-way comparison and produces a result of
   (C++20)                       type std::partial_ordering
                                 (customization point object)
                                 performs 3-way comparison and produces a result of
   compare_strong_order_fallback type std::strong_ordering, even if operator<=> is
   (C++20)                       unavailable
                                 (customization point object)

.SH Category:
     * Todo no example
